home *** CD-ROM | disk | FTP | other *** search
/ FishMarket 1.0 / FishMarket v1.0.iso / fishies / 626-637 / disk_633 / galer / source / jedec.c < prev    next >
C/C++ Source or Header  |  1992-05-06  |  9KB  |  379 lines
  1. /****************************************************************/
  2. /*                                */
  3. /* Jedec.c - enthält Routinen zum Laden und Speichern der    */
  4. /* GAL-Daten im Jedec-Format                    */
  5. /*                                */
  6. /* compilieren: cc Jedec.c                    */
  7. /*                                */
  8. /****************************************************************/
  9.  
  10.  
  11.  
  12. #include "exec/types.h"
  13. #include "exec/memory.h"
  14. #include <stdio.h>
  15. #include <ctype.h>
  16. #include <functions.h>
  17.  
  18. #include "GALer.h"
  19.  
  20.  
  21. extern    int        MaxFuseAdr;
  22. extern    int        GALType;
  23. extern    UBYTE        GadgetSBuff[60];
  24.  
  25. struct    JedecStruct    Jedec;
  26.  
  27.  
  28. int    bitnum, linenum;
  29.  
  30. UBYTE    *actptr, *buffend;
  31.  
  32.  
  33.  
  34.  
  35. /* PutJedec:
  36.    liest aus dem GAL die Jedec-Struktur ein und schreibt das Jedec-File 
  37.    Aufruf: PutJedec();
  38.        filename: Zeiger auf Filenamen (ohne ".jed")
  39. */
  40. PutJedec()
  41. {
  42.  if (MyRequest(ASK_REQ,(UBYTE *)"Jedec erstellen: Bitte GAL einsetzen")) {
  43.    if (MyRequest(SAVE_REQ,(UBYTE *)"Bitte Namen für Jedec-File eingeben")) {
  44.      ReadGALToJedec();                    /*GAL einlesen*/
  45.      WriteJedecFile();
  46.     }
  47.   }
  48. }
  49.  
  50.  
  51. /* WriteJedecFile:
  52.    erstellt aus der Jedec-Struktur das Jedec-File 
  53.    Aufruf: WriteJedecFile();
  54. */
  55. WriteJedecFile()
  56. {
  57. UBYTE    filenamebuff[64];
  58. FILE    *fp;
  59. int    n, m, bitnum;
  60.  
  61.      strcpy(&filenamebuff,&GadgetSBuff);        /*.jed an Dateinamen anfügen*/
  62.      strcat(&filenamebuff,(UBYTE *)".jed");
  63.      if (fp=fopen(&filenamebuff,(UBYTE *)"w")) {
  64.        bitnum = 0;
  65.        for (m=0; m<ROW_SIZE; m++) {
  66.      fprintf(fp,"*L%04d ",bitnum);
  67.          for (n=0; n<=MaxFuseAdr; n++) {
  68.        fprintf(fp,"%1d",Jedec.GALLogic[bitnum]);
  69.        bitnum++;
  70.       }
  71.      fprintf(fp,"\n");
  72.     }
  73.  
  74.        fprintf(fp,"*L%04d ",bitnum);            /*XOR*/
  75.        for (n=0; n<XOR_SIZE; n++) {
  76.      fprintf(fp,"%1d",Jedec.GALXOR[n]);
  77.      bitnum++;
  78.     }
  79.        fprintf(fp,"\n");
  80.  
  81.        fprintf(fp,"*L%04d ",bitnum);            /*Signatur*/
  82.        for (n=0; n<SIG_SIZE; n++) {
  83.      fprintf(fp,"%1d",Jedec.GALSig[n]);
  84.      bitnum++;
  85.         }
  86.        fprintf(fp,"\n");
  87.  
  88.        fprintf(fp,"*L%04d ",bitnum);            /*AC1*/
  89.        for (n=0; n<AC1_SIZE; n++) {
  90.      fprintf(fp,"%1d",Jedec.GALAC1[n]);
  91.      bitnum++;
  92.         }
  93.        fprintf(fp,"\n");
  94.  
  95.        fprintf(fp,"*L%04d ",bitnum);            /*Produkttermfreigabe*/
  96.        for (n=0; n<PT_SIZE; n++) {
  97.      fprintf(fp,"%1d",Jedec.GALPT[n]);
  98.      bitnum++;
  99.         }
  100.        fprintf(fp,"\n");
  101.  
  102.        fprintf(fp,"*L%04d %1d\n",bitnum,Jedec.GALSYN);    /*SYN*/
  103.        bitnum++;
  104.  
  105.        fprintf(fp,"*L%04d %1d\n",bitnum,Jedec.GALAC0);    /*AC0*/
  106.  
  107.        if (fclose(fp)==EOF) ErrorReq(8);        /*Datei läßt sich nicht schließem*/
  108.       }
  109. }
  110.  
  111.  
  112.  
  113.  
  114. /* GetJedec:
  115.    liest Jedec-File ein, wertet es aus und füllt die Jedec-Struktur
  116.    Aufruf: error=GetJedec(filename);
  117.        filename: Zeiger auf Filenamen (ohne ".jed")
  118.        error   : Fehlernummer; 0:keine Fehler 
  119. */
  120. GetJedec(filename)
  121. UBYTE    *filename;
  122. {
  123. UBYTE    filenamebuff[64];
  124. LONG    filesize;
  125. UBYTE    *filebuff;
  126. int    n, bit, Logic_Size;
  127.  
  128.  
  129.  strcpy(&filenamebuff,&GadgetSBuff);        /*.jed an Dateinamen anfügen*/
  130.  strcat(&filenamebuff,(UBYTE *)".jed");
  131.  
  132.  filesize=FileSize(&filenamebuff);
  133.  switch (filesize) {
  134.    case -1L: {
  135.      ErrorReq(1);
  136.      return(-1);
  137.      break;
  138.     }
  139.    case -2L: {
  140.      ErrorReq(2);
  141.      return(-2);
  142.      break;
  143.     }
  144.    case 0L: {
  145.      ErrorReq(4);
  146.      return(-4);
  147.      break;
  148.     }
  149.   }
  150.  if ((filebuff=(UBYTE *)AllocMem(filesize,MEMF_PUBLIC))) {
  151.    if ((ReadFile(&filenamebuff,filesize,filebuff))) {
  152.      PrintText((UBYTE *)"Datei ist geladen");
  153.      actptr=filebuff;
  154.      buffend=filebuff+filesize;
  155.      if (GALType==GAL16V8) Logic_Size=LOGIC16_SIZE;
  156.      else Logic_Size=LOGIC20_SIZE;
  157.  
  158.      bitnum  = 0;
  159.      linenum = 1;
  160.                     /*Jedec-Struktur erstellen*/
  161.      for (n=0; n<Logic_Size; n++) {        /*Logic-Matrix füllen*/
  162.     bit=GetNextBit();
  163.     if (bit==-1) {                /*Fehler aufgetreten?*/
  164.       FreeMem(filebuff,filesize);        /*ja, dann Speicher freigeben*/
  165.       return(-1);                /*und Fehlercode zurückgeben*/
  166.      }
  167.         Jedec.GALLogic[n]=(BYTE)bit;
  168.        }
  169.  
  170.      for (n=0; n<XOR_SIZE; n++) {        /*XOR-Feld füllen*/
  171.     bit=GetNextBit();
  172.     if (bit==-1) {                /*Fehler aufgetreten?*/
  173.       FreeMem(filebuff,filesize);        /*ja, dann Speicher freigeben*/
  174.       return(-1);                /*und Fehlercode zurückgeben*/
  175.      }
  176.         Jedec.GALXOR[n]=(BYTE)bit;
  177.        }
  178.  
  179.      for (n=0; n<SIG_SIZE; n++) {        /*Signatur-Feld füllen*/
  180.     bit=GetNextBit();
  181.     if (bit==-1) {                /*Fehler aufgetreten?*/
  182.       FreeMem(filebuff,filesize);        /*ja, dann Speicher freigeben*/
  183.       return(-1);                /*und Fehlercode zurückgeben*/
  184.      }
  185.         Jedec.GALSig[n]=(BYTE)bit;
  186.        }
  187.  
  188.      for (n=0; n<AC1_SIZE; n++) {        /*AC1-Feld füllen*/
  189.     bit=GetNextBit();
  190.     if (bit==-1) {                /*Fehler aufgetreten?*/
  191.       FreeMem(filebuff,filesize);        /*ja, dann Speicher freigeben*/
  192.       return(-1);                /*und Fehlercode zurückgeben*/
  193.      }
  194.         Jedec.GALAC1[n]=(BYTE)bit;
  195.        }
  196.  
  197.      for (n=0; n<PT_SIZE; n++) {        /*Produkttermfreigebe füllen*/
  198.     bit=GetNextBit();
  199.     if (bit==-1) {                /*Fehler aufgetreten?*/
  200.       FreeMem(filebuff,filesize);        /*ja, dann Speicher freigeben*/
  201.       return(-1);                /*und Fehlercode zurückgeben*/
  202.      }
  203.         Jedec.GALPT[n]=(BYTE)bit;
  204.        }
  205.  
  206.      bit=GetNextBit();                /*SYN-Bit */
  207.      if (bit==-1) {                /*Fehler aufgetreten?*/
  208.        FreeMem(filebuff,filesize);        /*ja, dann Speicher freigeben*/
  209.        return(-1);                /*und Fehlercode zurückgeben*/
  210.       }
  211.      Jedec.GALSYN=(BYTE)bit;
  212.  
  213.      bit=GetNextBit();                /* AC0-Bit*/
  214.      if (bit==-1) {                /*Fehler aufgetreten?*/
  215.        FreeMem(filebuff,filesize);        /*ja, dann Speicher freigeben*/
  216.        return(-1);                /*und Fehlercode zurückgeben*/
  217.       }
  218.      Jedec.GALAC0=(BYTE)bit;
  219.                     /*Jedec-Struktur fertig aufgebaut*/
  220.  
  221.      if (!(CheckFileEnd())) {            /*Dateiende erreicht?*/
  222.        JedecError(6);                /*nein, dann Fehler*/
  223.        return(-1);
  224.       }
  225.  
  226.      FreeMem(filebuff,filesize);
  227.      return(0);                    /*kein Fehler aufgetreten*/
  228.     }
  229.    else {
  230.      ErrorReq(3);                /*Lesefehler*/
  231.      FreeMem(filebuff,filesize);
  232.      return(-2);
  233.     }
  234.   }
  235.  else {
  236.    ErrorReq(2);                    /*kein Speicher*/
  237.    return(-2);
  238.   }
  239.  
  240. }
  241.  
  242.  
  243.  
  244. /* GetNextBit
  245.    gibt Wert des nächsten Bits zurück
  246.    Aufruf: bit=GetNextBit();
  247.           actptr: Zeiger auf aktuelle Textposition
  248.        bit: 0/1 = Bit; -1: Fehler
  249. */
  250. GetNextBit()
  251. {
  252. int    jedec_bit;
  253.  
  254.  if (CheckFileEnd()) {                    /*Dateiende vorzeitig erreicht?*/
  255.    JedecError(7);
  256.    return(-1);
  257.   }
  258.  
  259.  for(;;) {
  260.    switch (*actptr) {
  261.      case 0x0A: {                /*LineFeed*/
  262.        linenum++;                /*Zeilennummer erhöhen*/
  263.        actptr++;                /*Zeiger auf nächstes Zeichen*/
  264.        break;
  265.       }
  266.      case 0x09:                    /*TAB*/
  267.      case  ' ': {                /*Space*/
  268.        actptr++;                /*Zeiger auf nächstes Zeichen*/
  269.        break;
  270.       }
  271.  
  272.      case  '0': {                /*Bit=0*/
  273.        actptr++;
  274.        bitnum++;
  275.        return(0);
  276.       }
  277.  
  278.      case  '1': {                /*Bit=1*/
  279.        actptr++;
  280.        bitnum++;
  281.        return(1);
  282.       }
  283.      case  '*': {                /* * */
  284.        actptr++;
  285.        if (*actptr!='L') {            /*folgt L? nein, dann Syntax-Fehler*/
  286.      JedecError(1);
  287.      return(-1);
  288.     }
  289.        actptr++;
  290.        if (actptr>buffend) {            /*Dateiende?, dann Fehler*/
  291.      JedecError(2);
  292.      return(-1);
  293.     }
  294.        while ((*actptr==' ')||(*actptr==0x09))    /*Zeiger auf nächstes Zeichen*/
  295.      actptr++;
  296.        if (actptr>buffend) {            /*Dateiende?, dann Fehler*/
  297.      JedecError(2);
  298.      return(-1);
  299.     }
  300.        if (!(sscanf (actptr,"%d",&jedec_bit))) {
  301.      JedecError(3);
  302.      return(-1);                /*kein Zahl nach *L */       
  303.     }
  304.        if (jedec_bit!=bitnum) {
  305.      JedecError(4);
  306.      return(-1);                /*Jedec-Adresse ist falsch*/
  307.     }
  308.        while (isdigit(*actptr))
  309.      actptr++;
  310.        if (actptr>buffend) {            /*Dateiende?, dann Fehler*/
  311.      JedecError(2);
  312.      return(-1);
  313.     }
  314.        break;
  315.       }
  316.      default : {
  317.     JedecError(5);
  318.     return(-1);                /*unerlaubtes Zeichen*/
  319.  
  320.       }
  321.  
  322.     }
  323.   }
  324. }
  325.  
  326.  
  327. /*überprüfe, ob sich zwischen "actptr" und Dateiende noch Zeichen befinden
  328.   Aufruf:   answer=CheckFileEnd();
  329.         answer: 1=Dateiende erreicht; 0=Dateiende nicht erreicht
  330. */
  331. CheckFileEnd()
  332. {
  333. UBYTE    *ptr;
  334.  ptr = actptr;                    /*auf Dateiende testen*/
  335.  while (isspace(*ptr))
  336.    ptr++;
  337.  if (ptr>=buffend)
  338.    return(1);
  339.  else return(0);
  340. }
  341.  
  342.  
  343.  
  344. /*gibt Fehlermeldung aus*/
  345. JedecError(errornum)
  346. int    errornum;
  347. {
  348.  PrintErrorLine(linenum);
  349.  switch (errornum) {
  350.    case  1: { PrintText((UBYTE *)"Buchstabe 'L' erwartet");
  351.           break;
  352.         }
  353.    case  2: { PrintText((UBYTE *)"unerwartetes Dateiende");
  354.           break;
  355.         }
  356.    case  3: { PrintText((UBYTE *)"Zahl (Bit-Nummer) erwartet");
  357.           break;
  358.         }
  359.    case  4: { PrintText((UBYTE *)"Bit-Nummer stimmt mit Bit-Anzahl nicht überein");
  360.           break;
  361.         }
  362.    case  5: { PrintText((UBYTE *)"unerlaubtes Zeichen gefunden");
  363.           break;
  364.         }
  365.    case  6: { PrintText((UBYTE *)"Datei für eingestellten GAL-Typ zu lang");
  366.           break;
  367.         }
  368.    case  7: { PrintText((UBYTE *)"Datei für eingestellten GAL-Typ zu kurz");
  369.           break;
  370.         }
  371.   }
  372.  ErrorReq(5);
  373.  
  374. }
  375.  
  376.  
  377.  
  378.  
  379.